\begin{itemize}
				\item{\textbf{Acci\'on:}}
				El objetivo de la funci\'on es pixelar la imagen. Consiste en partir la imagen original en bloques de 4 x 4 pixeles. Para cado bloque de la imagen original se genera un bloque del mismo tama\~no en la imagen destino y a cada uno de sus pixeles se le asigna el promedio de los valores de los pixeles del bloque de la imagen original. El tama\~no (tanto ancho como alto) de la imagen destino es m\'ultiplo de 4, por lo tanto hemos tomado la decisi\'on que aquellos pixeles que no puedan ser tomados dentro de un bloque 4 x 4, sin tomar 2 pixeles en dos bloques distintos, no ser\'an procesados por el filtro. 
				\item{\textbf{Prototipo:}}
				void $pixelar$ (unsigned char* $src$, unsigned char* $dst$, int $h$, int $w$, int $src\_row\_size$, int $dst\_row\_size$)
				\item{\textbf{Procedimiento en C:}}
				En esta funci\'on recorremos la imagen de entrada ciclando las filas entre 0 y ($CantFilas$ - $restoFilas$) y las columnas entre 0 y ($CantCol$ - $restoCol$). Se rest\'o al ancho y largo el m\'odulo 4 del ancho/largo para poder recorrer tomando bloques de 4 x 4. En caso de existir pixeles que no entrasen en un bloque de 4 x 4 se tom\'o la decisi\'on de no filtrarlos. 
				En $promedioBloque$ hacemos la suma de los valores de todos los pixeles dentro del bloque. Luego divimos ese valor por 16 para obtener el promedio. No hace falta saturar el valor dado que al hacer el promedio sabemos que el resultado va a estar entre [0, 255].
				Una vez obtenido el promedio del bloque, nos situamos en la imagen destino y ponemos el valor en un bloque de 4 x 4 pixeles que tengan la misma ubicacion de columna y fila que los pixeles trabajados de la imagen de entrada. Esta funci\'on no realiza trabajo en paralelo, trabaja de a 1 bloque de 4 x 4 por iteraci\'on.  
				\item{\textbf{Procedimiento en ASM:}}
		 		En esta funcion recorremos la imagen de entrada agarrando, mediante instrucciones SSE y los registros $xmm$, 16 pixeles por fila. Lo que vamos a hacer es cargar en $xmm0$, $xmm1$, $xmm2$ y $xmm3$ 16 pixeles de 4 filas distintas. Qued\'andonos de la siguiente manera para el trabajo en paralelo:
		 		\begin{center}
				Estado Registros $xmm$\\ 
				\includegraphics[scale=0.45]{Images/tabla_xmm_pixelar.jpg}
				\end{center}
		 		Nos quedan acomodados 4 bloques de 4 x 4 para poder realizar las operacion bajo las instrucciones SSE.\\
		 		Como queremos sumar los 16 pixeles de cada bloque, nos podr\'ia no entrar el resultado en 1 byte (el peor caso ser\'ia 255*16 que entra en un $word$), por lo cual debemos pasar cada pixel a word y luego efectuar la sumatoria. Esto lo hacemos copiando los registros $xmm0$, $xmm1$, $xmm2$ y $xmm3$ a otros 4 registros del $xmm4$ al $xmm7$.
		 		Mediante la instrucci\'on $pmovzxbw$ extendemos con cero los bytes a word. Ahora tenemos 8 registros $xmm0$ al $xmm7$ en los cuales est\'an los pixeles en word. El registro $xmm4$ tiene la parte alta de $xmm0$, el $xmm5$ la parte alta de $xmm1$, etc. De esta manera tenemos los bloques 1 y 2 en los registros $xmm0$, $xmm1$, $xmm2$ y $xmm3$ y los bloques 3 y 4 en los registros $xmm4$, $xmm5$, $xmm6$ y $xmm7$:\\
		 		\begin{center}
				Estado Registros $xmm$\\
				\includegraphics[scale=0.45]{Images/tabla_xmm_pixelar2.jpg}
				\end{center}
		 		Sumamos de a word mediante $paddw$ $xmm0$ con $xmm1$ y $xmm2$ con $xmm3$. Luego sumamos de a word $xmm0$ con $xmm2$. En $xmm0$ tenemos 4 n\'umeros en word, debemos sumar estor cuatro word para tener la sumatoria de los 16 pixeles.\\\\
		 		$xmm0$ = $|$ Suma8 $|$ Suma7 $|$ Suma6 $|$ Suma5 $|$ Suma4 $|$ Suma3 $|$ Suma2 $|$ Suma1 $|$\\\\
				Para lograrlo copiamos $xmm0$ en otro registro y vamos lo corremos 2 bytes (1 word) hacia la derecha (mediante $psrldq$) y lo sumamos a $xmm0$. Pudiendo sumar Suma1 con Suma2 y Suma 3 con Suma 4.\\\\
				$xmm0$ = $|$ basura $|$ Suma7+8 $|$ basura $|$ Suma5+6 $|$ basura $|$ Suma3+4 $|$ basura $|$ Suma1+2$|$\\\\					
		 		Ahora a $xmm0$ le hacemos el corrimiento 4 bytes hacia la derecha para poder sumar Suma1+2 con Suma3+4 y Suma5+6 con Suma7+8, sumando de a word. Una vez hecho esto, tenemos en un word la sumaTotal de los 16 pixeles del bloque 1 y en otro word la sumaTotal del bloque 2. Debemos poner este los resultados en 4 words consecutivos.
		 		Con una serie de desplazamientos hacia derecha e izquierda y sumas de a word logramos tener en el registro\\\\
		 		$xmm0$ = $|$ ST2 $|$ ST2 $|$ ST2 $|$ ST2 $|$ ST1 $|$ ST1 $|$ ST1 $|$ ST1 $|$ (ST = SumaTotal)\\\\
		 		Se realiza el mismo procedimiento con los registros del $xmm4$ al $xmm7$, guardando la sumaTotal en $xmm4$.\\
		 		En $xmm0$ y $xmm4$ tenemos la sumaTotal de cada bloque en 4 words consecutivos. Tenemos que dividirlos por 16, para ello corremos cada word 4 bits hacia la derecha (con $psrlw$) dado el correr 1 bit hacia la derecha es equivalente a la divisi\'on por 2. Al finalizar esta instrucci\'on para ambos registros, tenemos el resultado de los filtro en $xmm0$ y $xmm4$. 
		 		Antes de pasarlos a la imagen destino debemos pasar los words a bytes.
		 		Eso lo realizamos con la instrucci\'on: $packuswb$ $xmm0$, $xmm4$, que convierte los words a byte
		 		Luego escribimos en la imagen de salida los 4 bloques de 4 x 4 con $xmm0$ y tenemos que avanzar 16 bytes para trabajar con nuevos valores. Si nos faltan menos de 16 bytes por recorrer retrocedemos tantos bloques de 4 x 4 para que podamos en la pr\'oxima iteraci\'on completar la columna. 
		 		Cuando llegamos a recorrer todas las columnas debemos avanzar fila, pero como escribimos de a 4 filas en el bloque avanzamos 4 filas en la imagen de entrada y salida.    
\end{itemize}
